package h0722;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

/**
 * @author 不知名帅哥
 * @version 1.0
 * @description 求幸存数之和
 * @date 2024/7/22 15:52
 */
public class FindSurvivors {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int[] array = Arrays.stream(sc.nextLine().split(",")).mapToInt(Integer::parseInt).toArray();
        int jump=sc.nextInt(); //跳数
        int m=sc.nextInt();  //幸存的数量
        int n=getResult(jump,m,array);
//        System.out.println(sumOfLeft(array,jump,m));
        System.out.println(n);
    }

    private static int getResult(int jump, int m, int[] array) {
        if (m>array.length){ //如果幸存数的数量大于数组长度，直接求和
            return Arrays.stream(array).sum();
        }

        List<Integer> list=new ArrayList<>();
        for (int a : array) {
            list.add(a);
        }
        // 从起跳点开始的话，需要跳jump+1次，到达需要删除的节点
        // 从起跳点下一个节点开始的话，需要跳jump次，到达需要删除的节点
        // 这里我们从起跳点的下一个节点开始,初始时起跳点为索引0，因此下一个节点为索引1
        int index=1;  //TODO !!!
        while (list.size()>m){
            index=index+jump;
            index=index%list.size();
            list.remove(index);
        }

        return list.stream().reduce(Integer::sum).orElse(0);
    }

    public static int sumOfLeft(int[] nums, int jump, int left){
        CycleLink cycleLink=new CycleLink(nums);

        cycleLink.next();
        while (cycleLink.size>left){
            int zipJump=jump%cycleLink.size;
            for (int i = 0; i < zipJump; i++) {
                cycleLink.next();
            }
            cycleLink.remove();//移除节点
        }
        int sum = cycleLink.sum;
        return sum;
    }

    static class Node{
        int val;
        Node prev;
        Node next;
        public Node(int val){
            this.val=val;
        }
    }

    static class CycleLink{
        private Node head;
        private Node tail;
        private Node cur;
        public int size;
        public int sum;

        //初始化循环链表
        public CycleLink(int[] nums){
            //向循环链表中添加节点
            for (int num : nums) {
                this.add(num);
            }
            //将普通链表头尾相连，形成循环链表
            if (this.head!=null){
                this.head.prev=this.tail;
                this.tail.next=this.head;
                //初始时循环链表的遍历指针指向头位值
                this.cur=this.head;
            }
        }

        private void add(int val){
            Node node=new Node(val);

            if (this.size==0){
                this.head=node;
                this.tail=node;
            }else {
                this.tail.next=node;
                node.prev=this.tail;
                this.tail=node;
            }
            this.sum+=val;
            this.size++;
        }

        //删除循环链表cur指针指向的节点
        public void remove(){
            //被删除节点的值从循环链表和中去除
            this.sum-=this.cur.val;
            //循环链表节点数量-1
            this.size--;

            //完成删除节点动作
            Node prev=this.cur.prev;
            Node next = this.cur.next;

            prev.next=next;
            next.prev=prev;

            this.cur.prev=null;
            this.cur.next=null;

            //遍历指针指向被删除节点的下一个节点
            this.cur=next;
        }
        // 遍历下一个循环链表节点
        public void next() {
            this.cur = this.cur.next;
        }

    }

}
